package code;

public class Code_1438 {


    public static void main(String[] args) {

        Code_1438 code_1438 = new Code_1438();
        int[] nums = new int[]{8, 2, 4, 7};
        int[] nums1 = new int[]{10,1,2,4,7,2};
        int[] nums2 = new int[]{4,2,2,2,4,4,2,2};
        int[] nums3 = new int[]{1,5,6,7,8,10,6,5,6};

      //  System.out.println(code_1438.longestSubarray(nums, 4));
      //  System.out.println(code_1438.longestSubarray(nums1, 5));
      //  System.out.println(code_1438.longestSubarray(nums2, 0));
        System.out.println(code_1438.longestSubarray(nums3, 4));
    }

    public int longestSubarray(int[] nums, int limit) {
        if (nums == null || limit < 0) {
            return 0;
        }
        int n = nums.length;

        // 0-连续子数组长度 1-最小值下标 2-最大值下标
        int[] dp = new int[n];
        dp[0] = 1;
        int maxIndex = 0, minIndex = 0;
        int max = 1;

        // 遍历数组
        for (int i = 1; i < nums.length; i++) {

            // 先默认使用上一个长度
    //        dp[i] = dp[i - 1];
            int cur = -1;
            // -1 最小值更改 0 不变 1 最大值更改
            int isMoreMaxOrMin = 0;
            // 更新最小值
            if (nums[i] < nums[minIndex]) {
                minIndex = i;
                // 从最大值的下标开始遍历
                cur = maxIndex + 1;
                isMoreMaxOrMin = -1;
            } else if (nums[i] > nums[maxIndex]) {// 更新最大值
                maxIndex = i;
                // 从最小值的下标开始遍历
                cur = minIndex + 1;
                isMoreMaxOrMin = 1;
            }

            // 更新了最值，且最大值和最小值差值大于limit
            if (isMoreMaxOrMin != 0 && nums[maxIndex] - nums[minIndex] > limit) {

                // 如果是最大值更新，最小值需要增大
                if (isMoreMaxOrMin == 1) {
                    minIndex = maxIndex;
                    for (; cur <= i; cur++) {
                        if (nums[cur] >= (nums[maxIndex] - limit)) {
                            dp[i] = Math.max(dp[i], i - cur + 1);
                            if (nums[cur] < nums[minIndex]) {
                                minIndex = cur;
                            }
                        } else {
                            dp[i] = i - cur;
                        }
                    }
                }
                // 如果是最小值更新，最大值需要减小
                if (isMoreMaxOrMin == -1) {
                    maxIndex = minIndex;
                    for (; cur <= i; cur++) {
                        if (nums[cur] <= (nums[minIndex] + limit)) {
                            dp[i] = Math.max(dp[i], i - cur + 1);
                            if (nums[cur] > nums[maxIndex]) {
                                maxIndex = cur;
                            }
                        } else {
                            dp[i] = i - cur;
                        }
                    }
                }

            } else {
                dp[i] = dp[i - 1] + 1;
            }
            System.out.println(dp[i]);
            max = Math.max(dp[i], max);
        }

        return max;
    }
}
